/**
 * 数据迁移工具
 * 负责将 localStorage 中的数据迁移到 IndexedDB
 * 确保数据的完整性和一致性
 */
class DataMigration {
    constructor(indexedDBStorage) {
        // IndexedDB 存储实例
        this.storage = indexedDBStorage;
        
        // 迁移状态标识键
        this.MIGRATION_FLAG_KEY = 'data_migration_completed';
        
        // 需要迁移的 localStorage 键列表
        this.MIGRATION_KEYS = [
            'todolist_data',           // 主要任务数据
            'todolist_trash_data'      // 回收站数据
        ];
    }

    /**
     * 检查是否需要进行数据迁移
     * @returns {Promise<boolean>}
     */
    async needsMigration() {
        try {
            // 等待 IndexedDB 完全准备就绪
            await this.storage.waitForReady();
            
            // 检查迁移标识
            const migrationCompleted = await this.storage.getItem(this.MIGRATION_FLAG_KEY);
            
            if (migrationCompleted) {
                return false; // 已经迁移过了
            }

            // 检查 localStorage 中是否有需要迁移的数据
            for (const key of this.MIGRATION_KEYS) {
                const data = localStorage.getItem(key);
                if (data && data.trim() !== '') {
                    return true; // 发现需要迁移的数据
                }
            }

            return false; // 没有需要迁移的数据
        } catch (error) {
            console.error('检查迁移状态失败:', error);
            return false;
        }
    }

    /**
     * 执行数据迁移
     * @returns {Promise<{success: boolean, migratedKeys: string[], errors: Array}>}
     */
    async migrate() {
        const result = {
            success: true,
            migratedKeys: [],
            errors: []
        };

        try {
            console.log('开始数据迁移...');

            // 等待 IndexedDB 初始化完成
            await this.storage.waitForReady();

            // 逐个迁移数据项
            for (const key of this.MIGRATION_KEYS) {
                try {
                    await this.migrateDataItem(key);
                    result.migratedKeys.push(key);
                    console.log(`成功迁移数据项: ${key}`);
                } catch (error) {
                    console.error(`迁移数据项 ${key} 失败:`, error);
                    result.errors.push({
                        key: key,
                        error: error.message
                    });
                    result.success = false;
                }
            }

            // 如果迁移成功，设置迁移完成标识
            if (result.success) {
                await this.storage.setItem(this.MIGRATION_FLAG_KEY, {
                    completed: true,
                    timestamp: Date.now(),
                    migratedKeys: result.migratedKeys
                });

                console.log('数据迁移完成，设置迁移标识');
            }

        } catch (error) {
            console.error('数据迁移过程中发生错误:', error);
            result.success = false;
            result.errors.push({
                key: 'migration_process',
                error: error.message
            });
        }

        return result;
    }

    /**
     * 迁移单个数据项
     * @param {string} key - localStorage 键
     * @returns {Promise<void>}
     */
    async migrateDataItem(key) {
        // 从 localStorage 获取数据
        const localStorageData = localStorage.getItem(key);
        
        if (!localStorageData || localStorageData.trim() === '') {
            console.log(`跳过空数据项: ${key}`);
            return;
        }

        try {
            // 验证 JSON 数据格式
            const parsedData = JSON.parse(localStorageData);
            
            // 检查 IndexedDB 中是否已存在该数据
            const existingData = await this.storage.getItem(key);
            
            if (existingData) {
                console.log(`数据项 ${key} 在 IndexedDB 中已存在，跳过迁移`);
                return;
            }

            // 将数据存储到 IndexedDB
            await this.storage.setItem(key, parsedData);
            
            console.log(`成功迁移数据项 ${key}，数据大小: ${localStorageData.length} 字符`);
            
        } catch (parseError) {
            console.error(`解析数据项 ${key} 失败:`, parseError);
            throw new Error(`数据格式无效: ${parseError.message}`);
        }
    }

    /**
     * 清理 localStorage 中的旧数据（可选操作）
     * @param {boolean} confirm - 是否确认清理
     * @returns {Promise<{success: boolean, clearedKeys: string[], errors: Array}>}
     */
    async cleanupLocalStorage(confirm = false) {
        const result = {
            success: true,
            clearedKeys: [],
            errors: []
        };

        if (!confirm) {
            console.log('需要明确确认才能清理 localStorage 数据');
            return result;
        }

        try {
            // 验证 IndexedDB 中的数据完整性
            const validationResult = await this.validateMigratedData();
            
            if (!validationResult.success) {
                throw new Error('IndexedDB 数据验证失败，不能清理 localStorage');
            }

            // 清理 localStorage 中的数据
            for (const key of this.MIGRATION_KEYS) {
                try {
                    if (localStorage.getItem(key)) {
                        localStorage.removeItem(key);
                        result.clearedKeys.push(key);
                        console.log(`清理 localStorage 数据项: ${key}`);
                    }
                } catch (error) {
                    console.error(`清理数据项 ${key} 失败:`, error);
                    result.errors.push({
                        key: key,
                        error: error.message
                    });
                    result.success = false;
                }
            }

        } catch (error) {
            console.error('清理 localStorage 过程中发生错误:', error);
            result.success = false;
            result.errors.push({
                key: 'cleanup_process',
                error: error.message
            });
        }

        return result;
    }

    /**
     * 验证迁移后的数据完整性
     * @returns {Promise<{success: boolean, validatedKeys: string[], errors: Array}>}
     */
    async validateMigratedData() {
        const result = {
            success: true,
            validatedKeys: [],
            errors: []
        };

        try {
            for (const key of this.MIGRATION_KEYS) {
                try {
                    // 获取 localStorage 和 IndexedDB 中的数据
                    const localData = localStorage.getItem(key);
                    const indexedData = await this.storage.getItem(key);

                    // 如果 localStorage 中有数据，验证 IndexedDB 中是否也有相同数据
                    if (localData && localData.trim() !== '') {
                        if (!indexedData) {
                            throw new Error(`IndexedDB 中缺少数据项: ${key}`);
                        }

                        // 比较数据内容
                        const localParsed = JSON.parse(localData);
                        const dataMatch = JSON.stringify(localParsed) === JSON.stringify(indexedData);
                        
                        if (!dataMatch) {
                            throw new Error(`数据项 ${key} 内容不匹配`);
                        }
                    }

                    result.validatedKeys.push(key);
                    console.log(`数据项 ${key} 验证通过`);

                } catch (error) {
                    console.error(`验证数据项 ${key} 失败:`, error);
                    result.errors.push({
                        key: key,
                        error: error.message
                    });
                    result.success = false;
                }
            }

        } catch (error) {
            console.error('数据验证过程中发生错误:', error);
            result.success = false;
            result.errors.push({
                key: 'validation_process',
                error: error.message
            });
        }

        return result;
    }

    /**
     * 获取迁移状态信息
     * @returns {Promise<Object>}
     */
    async getMigrationStatus() {
        try {
            const migrationInfo = await this.storage.getItem(this.MIGRATION_FLAG_KEY);
            const needsMigration = await this.needsMigration();

            return {
                completed: !!migrationInfo,
                needsMigration: needsMigration,
                migrationInfo: migrationInfo,
                availableKeys: this.MIGRATION_KEYS.filter(key => 
                    localStorage.getItem(key) && localStorage.getItem(key).trim() !== ''
                )
            };
        } catch (error) {
            console.error('获取迁移状态失败:', error);
            return {
                completed: false,
                needsMigration: false,
                migrationInfo: null,
                availableKeys: [],
                error: error.message
            };
        }
    }

    /**
     * 重置迁移状态（用于测试或重新迁移）
     * @returns {Promise<void>}
     */
    async resetMigrationStatus() {
        try {
            await this.storage.removeItem(this.MIGRATION_FLAG_KEY);
            console.log('迁移状态已重置');
        } catch (error) {
            console.error('重置迁移状态失败:', error);
            throw error;
        }
    }
}

// 导出类供其他模块使用
window.DataMigration = DataMigration;